home *** CD-ROM | disk | FTP | other *** search
/ Programming Sound Cards / Programming Sound Cards.iso / sound_52 / bend.ma < prev    next >
Text File  |  1995-01-01  |  18KB  |  617 lines
  1. #
  2. # bendlib.ma - (dx7) pitch bend library of Ravel routines
  3. #
  4. # Implementation Assumptions:
  5. #
  6. # 1. Setup for dx7 type instrument.
  7. # might work elsewhere as is but may take some changes.
  8. #
  9. # 2. check SEMITONEUNITS; i.e., no of pitch bend
  10. # units per semitone. We set poff to 1.
  11. #
  12. # 3. Assume that
  13. # dx7 is setup as follows:
  14. #    range 12 (an octave span for the bend)
  15. #    step 0 - continuous bend (not semitones)
  16. #
  17. #########################################
  18. # Functions supported:
  19. ##############################################################
  20. # 1. riff vibratto(note, bendTime, totalTime, vibrattoStep, velocity)
  21. #    vibrato on specified note. note issued here.
  22. #
  23. # 2. riff vnonote(firstNote, curbend, totalTime, vibrattoStep, velocity)
  24. #    vibratto on note already issued.
  25. #
  26. # 3. riff bendUp(firstNote, firstTime, bendTime, totalTime, interval, velocity, vibrattoFlag, vibrattoSteps)
  27. #    pitch bend up of interval of 1-12 semitones
  28. #
  29. # 4. riff bendDown(firstNote, firstTime, bendTime, totalTime, interval, velocity, vibrattoFlag, vibrattoSteps)
  30. #    pitch bend down of interval of 1-12 semitones
  31. #
  32. # 5. riff bendUpDown(firstNote, firstTime, bendTime, totalTime, interval, velocity, vibrattoFlag, vibrattoSteps)
  33. #    pitch bend up then down. Jan Hammer would like it. 
  34. #
  35. # There are also some test routines at the bottom with a test vco
  36. # driver.
  37. # 
  38. # They can function as examples of how to use the above riffs.
  39. # You might want to comment them out to reduce code size.
  40.  
  41. export
  42.     vibratto,        # riff
  43.     vnonote,        # riff
  44.     bendUp,            # riff
  45.     bendDown,        # riff
  46.     bendUpDown         # riff
  47. end
  48.  
  49. # bend units per semi-tone 
  50. SEMITONEUNITS = 680
  51. # bend units per whole-tone 
  52. WHOLETONEUNITS = 1360
  53. # bend units at pitchbend center
  54. BENDCENTER = 8192
  55.  
  56. #
  57. # vibratto - play vibratto around requested tone.
  58. #
  59. # time is broken up into two parts, bendTime and remainder.
  60. # bendTime comes first. This permits vibratto followed by
  61. # normal non-vibratto tone.
  62. #
  63. # vibrattoStep - range of bend around center tone.
  64. #    10 - minimum
  65. #    60 - medium
  66. #    100 - heavy
  67. # 
  68. riff vibratto(firstNote, bendTime, totalTime, vibrattoStep, velocity)
  69. # interval - number of semitones to bend up
  70.     int events
  71.     int bendIncrement
  72.     int curincrement
  73.     int bendvalue
  74.     int elapsedTime
  75.     int remainingTime
  76.  
  77.     # make sure pitch bend offset is set at 1 so
  78.     # that we use the true MIDI numbers in decimal
  79.     # Remember this is a compiler pseudo-op.
  80.     poff 1
  81.  
  82.     bendIncrement = vibrattoStep
  83.  
  84.     # play note with 0 eventime    
  85.     # the note lasts "totalTime" time before a noteoff
  86.     # is issued
  87.     note firstNote    0,totalTime        velocity
  88.  
  89.     bendvalue = BENDCENTER
  90.     # start off with pitch bend wheel centered
  91.     # take no time to do this
  92.     bend    0    BENDCENTER
  93.  
  94.     # loop through pitch bend up
  95.     elapsedTime = 0
  96.     for ( events = 0; events < bendTime; events++)
  97.         # alternate up/down around pitch
  98.         if ({events % 2} == 0)
  99.             bend 1 BENDCENTER+bendIncrement
  100.         else
  101.             bend 1 BENDCENTER-bendIncrement 
  102.         end
  103.         elapsedTime++
  104.     end
  105.     # issue another pitch bend to make sure we
  106.     # arrived where we want because for loop
  107.     # above may not have arrived precisely
  108.     bend 0    BENDCENTER 
  109.     # use bend constant to return pitchbend wheel to center
  110.     poff 1
  111.     # deterime amount of eventtime remaining
  112.     # we may have some slop if the amount of time
  113.     # spent playing bends did not equal the bendTime
  114.     if (elapsedTime == bendTime)
  115.         remainingTime = totalTime - bendTime
  116.     else
  117.         remainingTime = {bendTime - elapsedTime} + {totalTime - bendTime}
  118.     end
  119.     # tie note for remaining time
  120.     tie  remainingTime
  121. #     void printf("bend %d \n",BENDCENTER)
  122.     # issue rest to make sure noteoff in effect. this
  123.     # is paranoia most likely
  124.     rest 0
  125.     # put pitchbend wheel at center
  126.     bend 0 BENDCENTER
  127. #    void dumptime()
  128. end
  129.  
  130. #
  131. # vnonote - play vibratto around requested tone. Used
  132. #    by other bend routines. Does not issue initial note.
  133. #    Also assumes that we do pitch bend for entire totalTime.
  134. #    I.e., not broken up into pitch bend, no pitch bend step.
  135. #
  136. # vibrattoStep - range of bend around center tone.
  137. #    10 - minimum
  138. #    60 - medium
  139. #    100 - heavy
  140. # 
  141. riff vnonote(firstNote, curbend, totalTime, vibrattoStep, velocity)
  142. # interval - number of semitones to bend up
  143.     int events
  144.     int bendvalue
  145.     int bendIncrement
  146.     int elapsedTime
  147.     int remainingTime
  148.  
  149.     # make sure pitch bend offset is set at 1 so
  150.     # that we use the true MIDI numbers in decimal
  151.     poff 1
  152.  
  153.     bendIncrement = vibrattoStep
  154.  
  155.     bendvalue = curbend
  156.  
  157.     # loop through pitch bend up
  158.     for ( events = 0; events < totalTime; events++)
  159.         # alternate up/down around pitch
  160.         if ({events % 2} == 0)
  161.             bend 1 bendvalue+bendIncrement
  162.         else
  163.             bend 1 bendvalue-bendIncrement 
  164.         end
  165.     end
  166.     # issue another pitch bend to make sure we
  167.     # arrived where we want because for loop
  168.     # above may not have arrived precisely
  169.     bend 0    bendvalue 
  170.     # issue rest to make sure noteoff in effect. this
  171.     # is paranoia most likely
  172.     rest 0
  173. #    void dumptime()
  174.     bend 0 BENDCENTER
  175. end
  176.  
  177. #
  178. # bendUp according to specified interval.
  179. #
  180. # Eventtime is broken up according to following scheme.
  181. #
  182. #    1. issue note for firstTime events
  183. #    2. bend for bendTime events
  184. #    3. tie for remaining time (totalTime - (firstTime + bendTime)
  185. #    Latter non-bend time may have vibratto attached.
  186. #
  187. # e.g.,
  188. #    C, e, e, q, 2, 100, 0, 0 
  189. #
  190. # would mean play C for e events, then bend to D for e events,
  191. # and quit with no vibratto at end.
  192. #
  193. # firstnote - starting note
  194. # firstTime - time devoted to first note before bend
  195. # bendTime - period of time for bends
  196. # totalTime - total elapsed time for note to note. If totalTime
  197. #    is larger than bendTime, we do the pitch bend first
  198. #    and spend the remaining amount of time on the note.
  199. # interval - 1..12 semitones.
  200. # velocity - desired velocity.
  201. # vibratto - flag, 1 for TRUE, 0 for FALSE, if specified
  202. # then we use vibratto for last totalTime-bendTime period.
  203. # This permits more guitar-like effects.
  204. # vibrattoStep - how much pitch bend for vibratto
  205. #
  206. # bendUp(C, 0, h, w, 12, 100, 0, 0)
  207. # would execute a linear bend from C to HC for the first 'h'
  208. # of time, and then execute the HC for the 2nd 'h' with
  209. # total elapsed time of 'w'.
  210. #
  211. # Algorithm needs work but this gets the job done.
  212. #
  213.  
  214. riff bendUp(firstNote, firstTime, bendTime, totalTime, interval, velocity, vflag, vsteps)
  215. # interval - number of semitones to bend up
  216.     int events
  217.     int bendIncrement
  218.     int totalBendUnits
  219.     int pertimeClick
  220.     int curincrement
  221.     int bendvalue
  222.     int elapsedTime
  223.     int remainingTime
  224.  
  225.     # make sure pitch bend offset is set at 1 so
  226.     # that we use the true MIDI numbers in decimal
  227.     poff 1
  228.  
  229.     # don't set interval to 0
  230.     if (interval == 0)
  231.         void printf("bendUp: invalid 0 interval\n")
  232.         final
  233.     end
  234.     # total number of bend units to cover interval
  235.     totalBendUnits = interval * SEMITONEUNITS
  236.  
  237.     # determine per bend event time and how much
  238.     # to bend per bend call
  239.     # if more time than total bend units according
  240.     # to the interval, then divide the time
  241.     # by the number of bend units to get the per
  242.     # bend call time, otherwise time is 1
  243.     if (bendTime > totalBendUnits)
  244.         pertimeClick = bendTime / totalBendUnits
  245.         bendIncrement = totalBendUnits / pertimeClick
  246.     else
  247.         bendIncrement = totalBendUnits / bendTime
  248.         pertimeClick = 1
  249.     end
  250.  
  251. #     void printf("bendIncrement %d\n",bendIncrement)
  252. #     void printf("pertimeClick %d\n",pertimeClick)
  253. #     void printf("totalBendUnits %d\n",totalBendUnits)
  254.  
  255.     # play note with 0 eventime    
  256.     # the note lasts "totalTime" time before a noteoff
  257.     # is issued
  258.     note firstNote    firstTime,totalTime        velocity
  259. #    void dumptime()
  260.     bendvalue = BENDCENTER
  261.     # start off with pitch bend wheel centered
  262.     # take no time to do this
  263.     poff 1
  264.     bend    0    BENDCENTER
  265.     curincrement = bendIncrement
  266.     # loop through pitch bend up
  267.     elapsedTime = 0
  268.     for ( events = 0; events < bendTime; events++)
  269.         bend pertimeClick BENDCENTER+curincrement 
  270. #        void printf("%d %d\n",pertimeClick,BENDCENTER+curincrement)
  271.         curincrement = curincrement + bendIncrement
  272.         elapsedTime = elapsedTime + pertimeClick
  273.     end
  274.     # issue another pitch bend to make sure we
  275.     # arrived where we want because for loop
  276.     # above may not have arrived precisely
  277.     bend 0    BENDCENTER + totalBendUnits
  278.  
  279.  
  280.     # use bend constant to return pitchbend wheel to center
  281.     poff 1
  282.     # deterime amount of eventtime remaining
  283.     # we may have some slop if the amount of time
  284.     # spent playing bends did not equal the bendTime
  285.     if (elapsedTime == bendTime)
  286.         remainingTime = totalTime - {firstTime + bendTime}
  287.     else
  288.         remainingTime = {bendTime - elapsedTime} + {totalTime - {bendTime + firstTime}}
  289.     end
  290.     # do vibratto for last half
  291.     # use special vibratto routine that does not issue note
  292.     # just bends
  293.     if (vflag)
  294.         void vnonote(firstNote, BENDCENTER+totalBendUnits, remainingTime, vsteps, velocity)
  295.         return(0)
  296.     end
  297.     # tie note for remaining time
  298.     tie  remainingTime
  299. #     void printf("bend %d \n",BENDCENTER)
  300.     # issue rest to make sure noteoff in effect. this
  301.     # is paranoia most likely
  302.     rest 0
  303.     # put pitchbend wheel at center
  304.     bend 0 BENDCENTER
  305. #    void dumptime()
  306. end
  307.  
  308. #
  309. # bend Down requested interval
  310. #
  311. # interval 0..12: max range an octave
  312. riff bendDown(firstNote, firstTime, bendTime, totalTime, interval, velocity, vflag, vsteps)
  313. # interval - number of semitones to bend up
  314.     int events
  315.     int bendIncrement
  316.     int totalBendUnits
  317.     int pertimeClick
  318.     int curincrement
  319.     int bendvalue
  320.     int elapsedTime
  321.     int remainingTime
  322.  
  323.     # make sure pitch bend offset is set at 1 so
  324.     # that we use the true MIDI numbers in decimal
  325.     poff 1
  326.  
  327.     # don't set interval to 0
  328.     if (interval == 0)
  329.         void printf("bendUp: invalid 0 interval\n")
  330.         final
  331.     end
  332.     # total number of bend units to cover interval
  333.     totalBendUnits = interval * SEMITONEUNITS
  334.  
  335.     # determine per bend event time and how much
  336.     # to bend per bend call
  337.     # if more time than total bend units according
  338.     # to the interval, then divide the time
  339.     # by the number of bend units to get the per
  340.     # bend call time, otherwise time is 1
  341.     if (bendTime > totalBendUnits)
  342.         pertimeClick = bendTime / totalBendUnits
  343.         bendIncrement = totalBendUnits / pertimeClick
  344.     else
  345.         bendIncrement = totalBendUnits / bendTime
  346.         pertimeClick = 1
  347.     end
  348.  
  349. #     void printf("bendIncrement %d\n",bendIncrement)
  350. #     void printf("pertimeClick %d\n",pertimeClick)
  351. #     void printf("totalBendUnits %d\n",totalBendUnits)
  352.  
  353.     # play note with 0 eventime    
  354.     # the note lasts "totalTime" time before a noteoff
  355.     # is issued
  356.     note firstNote    firstTime, totalTime        velocity
  357. #    void dumptime()
  358.     bendvalue = BENDCENTER
  359.     # start off with pitch bend wheel centered
  360.     # take no time to do this
  361.     poff 1
  362.     bend    0    BENDCENTER
  363.     curincrement = bendIncrement
  364.     # loop through pitch bend up
  365.     elapsedTime = 0
  366.     for ( events = 0; events < bendTime; events++)
  367.         bend pertimeClick BENDCENTER-curincrement 
  368. #        void printf("%d %d\n",pertimeClick,BENDCENTER+curincrement)
  369.         curincrement = curincrement + bendIncrement
  370.         elapsedTime = elapsedTime + pertimeClick
  371.     end
  372.     # issue another pitch bend to make sure we
  373.     # arrived where we want because for loop
  374.     # above may not have arrived precisely
  375.     bend 0    BENDCENTER - totalBendUnits
  376. #    void printf("%d \n",BENDCENTER+totalBendUnits)
  377.     # use bend constant to return pitchbend wheel to center
  378.     poff 1
  379.     # deterime amount of eventtime remaining
  380.     # we may have some slop if the amount of time
  381.     # spent playing bends did not equal the bendTime
  382.     if (elapsedTime == bendTime)
  383.         remainingTime = totalTime - {firstTime + bendTime}
  384.     else
  385.         remainingTime = {bendTime - elapsedTime} + {totalTime - {bendTime + firstTime}}
  386.     end
  387.     # do vibratto for last half
  388.     # use special vibratto routine that does not issue note
  389.     # just bends
  390.     if (vflag)
  391.         void vnonote(firstNote, BENDCENTER-totalBendUnits, remainingTime, vsteps, velocity)
  392.         return(0)
  393.     end
  394.     # tie note for remaining time
  395.     tie  remainingTime
  396. #     void printf("bend %d \n",BENDCENTER)
  397.     # issue rest to make sure noteoff in effect. this
  398.     # is paranoia most likely
  399.     rest 0
  400.     # put pitchbend wheel at center
  401.     bend 0 BENDCENTER
  402. #    void dumptime()
  403. end
  404.  
  405. #
  406. # bendUpDown
  407. #
  408. # bend up interval requested
  409. # then bend down
  410. #
  411. riff bendUpDown(firstNote, firstTime, bendTime, totalTime, interval, velocity, vflag, vsteps)
  412. # interval - number of semitones to bend up
  413.     int events
  414.     int bendIncrement
  415.     int totalBendUnits
  416.     int pertimeClick
  417.     int curincrement
  418.     int bendvalue
  419.     int elapsedTime
  420.     int remainingTime
  421.     int firstHalf    # first half of time delta
  422.     int secondHalf    # second half of time delta
  423.  
  424.     # make sure pitch bend offset is set at 1 so
  425.     # that we use the true MIDI numbers in decimal
  426.     poff 1
  427.  
  428.     # don't set interval to 0
  429.     if (interval == 0)
  430.         void printf("bendUp: invalid 0 interval\n")
  431.         final
  432.     end
  433.  
  434.     # split bend timedelta into first half and second
  435.     # half and make sure all events are accounted for
  436.     # in time
  437.     firstHalf = bendTime >> 1
  438.     if ({bendTime % 2} != 0)
  439.         secondHalf = firstHalf + 1
  440.     else
  441.         secondHalf = firstHalf
  442.     end
  443.  
  444.     # total number of bend units to cover interval
  445.     totalBendUnits = interval * SEMITONEUNITS
  446.  
  447.     # determine per bend event time and how much
  448.     # to bend per bend call
  449.     # if more time than total bend units according
  450.     # to the interval, then divide the time
  451.     # by the number of bend units to get the per
  452.     # bend call time, otherwise time is 1
  453.     if (firstHalf > totalBendUnits)
  454.         pertimeClick = firstHalf / totalBendUnits
  455.         bendIncrement = totalBendUnits / pertimeClick
  456.     else
  457.         bendIncrement = totalBendUnits / firstHalf
  458.         pertimeClick = 1
  459.     end
  460.  
  461. #     void printf("bendIncrement %d\n",bendIncrement)
  462. #     void printf("pertimeClick %d\n",pertimeClick)
  463. #     void printf("totalBendUnits %d\n",totalBendUnits)
  464.  
  465.     # play note with 0 eventime    
  466.     # the note lasts "totalTime" time before a noteoff
  467.     # is issued
  468.     note firstNote    firstTime,totalTime        velocity
  469. #    void dumptime()
  470.     bendvalue = BENDCENTER
  471.     # start off with pitch bend wheel centered
  472.     # take no time to do this
  473.     poff 1
  474.     bend    0    BENDCENTER
  475.     curincrement = bendIncrement
  476.     # loop through pitch bend up
  477.     elapsedTime = 0
  478.     for ( events = 0; events < firstHalf; events++)
  479.         bend pertimeClick BENDCENTER+curincrement 
  480. #        void printf("%d %d\n",pertimeClick,BENDCENTER+curincrement)
  481.         curincrement = curincrement + bendIncrement
  482.         elapsedTime = elapsedTime + pertimeClick
  483.     end
  484.  
  485.     # make sure we got to top
  486.     bend 0    BENDCENTER + totalBendUnits
  487.     curincrement = totalBendUnits
  488.  
  489.     # now loop down, keep running totals
  490.     for ( events = 0; events < secondHalf; events++)
  491.         bend pertimeClick BENDCENTER+curincrement
  492. #        void printf("%d %d\n",pertimeClick,BENDCENTER+curincrement)
  493.         curincrement = curincrement - bendIncrement
  494.         elapsedTime = elapsedTime + pertimeClick
  495.     end
  496.  
  497.     # issue another pitch bend to make sure we
  498.     # arrived where we want because for loop
  499.     # above may not have arrived precisely
  500.     bend 0    BENDCENTER 
  501.  
  502. #    void printf("%d \n",BENDCENTER+totalBendUnits)
  503.     # use bend constant to return pitchbend wheel to center
  504.     poff 1
  505.     # deterime amount of eventtime remaining
  506.     # we may have some slop if the amount of time
  507.     # spent playing bends did not equal the bendTime
  508.     if (elapsedTime == bendTime)
  509.         remainingTime = totalTime - {firstTime + bendTime}
  510.     else
  511.         remainingTime = {bendTime - elapsedTime} + {totalTime - {bendTime + firstTime}}
  512.     end
  513.     if (vflag)
  514.         void vnonote(firstNote, BENDCENTER, remainingTime, vsteps, velocity)
  515.         return(0)
  516.     end
  517.  
  518.     # tie note for remaining time
  519.     tie  remainingTime
  520. #     void printf("bend %d \n",BENDCENTER)
  521.     # issue rest to make sure noteoff in effect. this
  522.     # is paranoia most likely
  523.     rest 0
  524.     # put pitchbend wheel at center
  525.     bend 0 BENDCENTER
  526. #    void dumptime()
  527. end
  528.  
  529.  
  530. # should start with 4 note chord from LLC to LC range
  531. # LLC, LE, LG, LC to LC, E, G, HC octave bend. Fun.
  532. # then play major scale via bends twice.
  533. # finish off with normal C to HC for contrast
  534. #
  535. riff testBendUp()
  536.     int i
  537.     void printf("C chord bend up\n")
  538.     LG    0,w
  539.     LE    0,w
  540.     LLC    0,w
  541.     void bendUp(LC, 0, h, w, 12, 100, 0, 0)
  542.     void printf("C scale down twice\n")
  543.     for ( i = 0; i < 2; i++)
  544.         C    q
  545.         # up to D
  546.         void bendUp(C, 0, e, q, 2, 100, 0, 0)
  547.         # up to E
  548.         void bendUp(D, 0, e, q, 2, 100, 0, 0)
  549.         # up to F
  550.         void bendUp(E, 0, e, q, 1, 100, 0, 0)
  551.         void bendUp(F, 0, e, q, 2, 100, 0, 0)
  552.         void bendUp(G, 0, e, q, 2, 100, 0, 0)
  553.         void bendUp(A, 0, e, q, 2, 100, 0, 0)
  554.         void bendUp(B, 0, e, q, 1, 100, 0, 0)
  555.     end
  556.     void printf("C HC reference tones\n")
  557.     C    q
  558.     HC    q
  559.  
  560. end
  561.  
  562. riff testBendDown()
  563.     void printf("bend down: C scale down to G\n")
  564.     # C
  565.     note C    q    127
  566.     # C to LB
  567.     void bendDown(C, 0, e, q, 1, 127, 0, 0)
  568.     # LB to LA
  569.     void bendDown(LB, 0, e, q, 2, 127, 0, 0)
  570.     # LA to LG
  571.     void printf("bend down: LG scale down to LC\n")
  572.     void bendDown(LA, 0, e, q, 2, 127, 0, 0)
  573.     # LG to LC
  574.     void bendDown(LG, 0, e, q, 7, 127, 0, 0)
  575.  
  576.  
  577.     void printf("C then C to LC\n")
  578.     C    q
  579.     void bendDown(C, 0, q, w, 12, 127, 0, 0) 
  580.     #
  581.     void printf("reference tones LC C \n")
  582.     LC    q
  583.     C    q
  584. end
  585.  
  586. riff testVibratto()
  587.     int vsteps
  588.     int i
  589.     vsteps = 0
  590.     for ( i = 0 ; i < 20; i++)
  591.         void printf("vsteps %d\n",vsteps)
  592.         void vibratto(C, q*3, w, vsteps, 100)
  593.         vsteps = vsteps + 10
  594.     end
  595. end
  596.  
  597. riff testguitarRiff()
  598.     void bendUp(LG, 2, e+2, q, 2, 110, 1, 70)
  599.  
  600.     void vibratto(LA, q,q, 80, 100)
  601.     void vibratto(E, q,q, 60, 100)
  602.     void bendUpDown(D, 3, q+e-3, q+e, 2, 110, 0, 0)
  603.     void vibratto(C, e, e, 50, 100)
  604.     void vibratto(LA, 3*q,3*q, 110, 100)
  605.     rest    e
  606.     void bendUp(LG, 0, e, q+e, 2, 110, 1, 110)
  607. end
  608.  
  609. vco testBendLib()
  610.     void testguitarRiff()
  611.     void testBendUp()
  612.     void testBendDown()
  613.     void testVibratto()
  614. end
  615.  
  616.  
  617.